home *** CD-ROM | disk | FTP | other *** search
/ Aminet 8 / Aminet 8 (1995)(GTI - Schatztruhe)[!][Oct 1995].iso / Aminet / dev / gcc / gcc270_src.lha / gcc-2.7.0-amiga / config / i960 / i960.c < prev    next >
C/C++ Source or Header  |  1995-06-15  |  61KB  |  2,413 lines
  1. /* Subroutines used for code generation on intel 80960.
  2.    Copyright (C) 1992, 1995 Free Software Foundation, Inc.
  3.    Contributed by Steven McGeady, Intel Corp.
  4.    Additional Work by Glenn Colon-Bonet, Jonathan Shapiro, Andy Wilson
  5.    Converted to GCC 2.0 by Jim Wilson and Michael Tiemann, Cygnus Support.
  6.  
  7. This file is part of GNU CC.
  8.  
  9. GNU CC is free software; you can redistribute it and/or modify
  10. it under the terms of the GNU General Public License as published by
  11. the Free Software Foundation; either version 2, or (at your option)
  12. any later version.
  13.  
  14. GNU CC is distributed in the hope that it will be useful,
  15. but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. GNU General Public License for more details.
  18.  
  19. You should have received a copy of the GNU General Public License
  20. along with GNU CC; see the file COPYING.  If not, write to
  21. the Free Software Foundation, 59 Temple Place - Suite 330,
  22. Boston, MA 02111-1307, USA.  */
  23.  
  24. #include <stdio.h>
  25.  
  26. #include "config.h"
  27. #include "rtl.h"
  28. #include "regs.h"
  29. #include "hard-reg-set.h"
  30. #include "real.h"
  31. #include "insn-config.h"
  32. #include "conditions.h"
  33. #include "insn-flags.h"
  34. #include "output.h"
  35. #include "insn-attr.h"
  36. #include "flags.h"
  37. #include "tree.h"
  38. #include "insn-codes.h"
  39. #include "assert.h"
  40. #include "expr.h"
  41. #include "function.h"
  42. #include "recog.h"
  43. #include <math.h>
  44.  
  45. /* Save the operands last given to a compare for use when we
  46.    generate a scc or bcc insn.  */
  47.  
  48. rtx i960_compare_op0, i960_compare_op1;
  49.  
  50. /* Used to implement #pragma align/noalign.  Initialized by OVERRIDE_OPTIONS
  51.    macro in i960.h.  */
  52.  
  53. static int i960_maxbitalignment;
  54. static int i960_last_maxbitalignment;
  55.  
  56. /* Used to implement switching between MEM and ALU insn types, for better
  57.    C series performance.  */
  58.  
  59. enum insn_types i960_last_insn_type;
  60.  
  61. /* The leaf-procedure return register.  Set only if this is a leaf routine.  */
  62.  
  63. static int i960_leaf_ret_reg;
  64.  
  65. /* True if replacing tail calls with jumps is OK.  */
  66.  
  67. static int tail_call_ok;
  68.  
  69. /* A string containing a list of insns to emit in the epilogue so as to
  70.    restore all registers saved by the prologue.  Created by the prologue
  71.    code as it saves registers away.  */
  72.  
  73. char epilogue_string[1000];
  74.  
  75. /* A unique number (per function) for return labels.  */
  76.  
  77. static int ret_label = 0;
  78.  
  79. /* This is true if FNDECL is either a varargs or a stdarg function.
  80.    This is used to help identify functions that use an argument block.  */
  81.  
  82. #define VARARGS_STDARG_FUNCTION(FNDECL)    \
  83. ((TYPE_ARG_TYPES (TREE_TYPE (FNDECL)) != 0                              \
  84.   && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (FNDECL)))) != void_type_node))    \
  85.  || current_function_varargs)
  86.  
  87. /* Handle pragmas for compatibility with Intel's compilers.  */
  88.  
  89. /* ??? This is incomplete, since it does not handle all pragmas that the
  90.    intel compilers understand.  */
  91.  
  92. void
  93. process_pragma (finput)
  94.      FILE *finput;
  95. {
  96.   int c;
  97.   int i;
  98.  
  99.   c = getc (finput);
  100.   while (c == ' ' || c == '\t')
  101.     c = getc (finput);
  102.  
  103.   if (c == 'a'
  104.       && getc (finput) == 'l'
  105.       && getc (finput) == 'i'
  106.       && getc (finput) == 'g'
  107.       && getc (finput) == 'n'
  108.       && ((c = getc (finput)) == ' ' || c == '\t' || c == '\n'))
  109.     {
  110.       char buf[20];
  111.       char *s = buf;
  112.       int align;
  113.  
  114.       while (c == ' ' || c == '\t')
  115.     c = getc (finput);
  116.       if (c == '(')
  117.     c = getc (finput);
  118.       while (c >= '0' && c <= '9')
  119.     {
  120.       if (s < buf + sizeof buf - 1)
  121.         *s++ = c;
  122.       c = getc (finput);
  123.     }
  124.       *s = '\0';
  125.  
  126.       align = atoi (buf);
  127.       switch (align)
  128.     {
  129.     case 0:
  130.       /* Return to last alignment.  */
  131.       align = i960_last_maxbitalignment / 8;
  132.       /* Fall through.  */
  133.     case 16:
  134.     case 8:
  135.     case 4:
  136.     case 2:
  137.     case 1:
  138.       i960_last_maxbitalignment = i960_maxbitalignment;
  139.       i960_maxbitalignment = align * 8;
  140.       break;
  141.  
  142.     default:
  143.       /* Silently ignore bad values.  */
  144.       break;
  145.     }
  146.  
  147.       /* NOTE: ic960 R3.0 pragma align definition:
  148.  
  149.      #pragma align [(size)] | (identifier=size[,...])
  150.      #pragma noalign [(identifier)[,...]]
  151.  
  152.      (all parens are optional)
  153.  
  154.      - size is [1,2,4,8,16]
  155.      - noalign means size==1
  156.      - applies only to component elements of a struct (and union?)
  157.      - identifier applies to structure tag (only)
  158.      - missing identifier means next struct
  159.  
  160.      - alignment rules for bitfields need more investigation  */
  161.     }
  162.  
  163.   /* Should be pragma 'far' or equivalent for callx/balx here.  */
  164.  
  165.   ungetc (c, finput);
  166. }
  167.  
  168. /* Initialize variables before compiling any files.  */
  169.  
  170. void
  171. i960_initialize ()
  172. {
  173.   if (TARGET_IC_COMPAT2_0)
  174.     {
  175.       i960_maxbitalignment = 8;
  176.       i960_last_maxbitalignment = 128;
  177.     }
  178.   else
  179.     {
  180.       i960_maxbitalignment = 128;
  181.       i960_last_maxbitalignment = 8;
  182.     }
  183. }
  184.  
  185. /* Return true if OP can be used as the source of an fp move insn.  */
  186.  
  187. int
  188. fpmove_src_operand (op, mode)
  189.      rtx op;
  190.      enum machine_mode mode;
  191. {
  192.   return (GET_CODE (op) == CONST_DOUBLE || general_operand (op, mode));
  193. }
  194.  
  195. #if 0
  196. /* Return true if OP is a register or zero.  */
  197.  
  198. int
  199. reg_or_zero_operand (op, mode)
  200.      rtx op;
  201.      enum machine_mode mode;
  202. {
  203.   return register_operand (op, mode) || op == const0_rtx;
  204. }
  205. #endif
  206.  
  207. /* Return truth value of whether OP can be used as an operands in a three
  208.    address arithmetic insn (such as add %o1,7,%l2) of mode MODE.  */
  209.  
  210. int
  211. arith_operand (op, mode)
  212.      rtx op;
  213.      enum machine_mode mode;
  214. {
  215.   return (register_operand (op, mode) || literal (op, mode));
  216. }
  217.  
  218. /* Return true if OP is a register or a valid floating point literal.  */
  219.  
  220. int
  221. fp_arith_operand (op, mode)
  222.      rtx op;
  223.      enum machine_mode mode;
  224. {
  225.   return (register_operand (op, mode) || fp_literal (op, mode));
  226. }
  227.  
  228. /* Return true is OP is a register or a valid signed integer literal.  */
  229.  
  230. int
  231. signed_arith_operand (op, mode)
  232.      rtx op;
  233.      enum machine_mode mode;
  234. {
  235.   return (register_operand (op, mode) || signed_literal (op, mode));
  236. }
  237.  
  238. /* Return truth value of whether OP is a integer which fits the
  239.    range constraining immediate operands in three-address insns.  */
  240.  
  241. int
  242. literal (op, mode)
  243.      rtx op;
  244.      enum machine_mode mode;
  245. {
  246.   return ((GET_CODE (op) == CONST_INT) && INTVAL(op) >= 0 && INTVAL(op) < 32);
  247. }
  248.  
  249. /* Return true if OP is a float constant of 1.  */
  250.  
  251. int
  252. fp_literal_one (op, mode)
  253.      rtx op;
  254.      enum machine_mode mode;
  255. {
  256.   return (TARGET_NUMERICS && mode == GET_MODE (op) && op == CONST1_RTX (mode));
  257. }
  258.  
  259. /* Return true if OP is a float constant of 0.  */
  260.  
  261. int
  262. fp_literal_zero (op, mode)
  263.      rtx op;
  264.      enum machine_mode mode;
  265. {
  266.   return (TARGET_NUMERICS && mode == GET_MODE (op) && op == CONST0_RTX (mode));
  267. }
  268.  
  269. /* Return true if OP is a valid floating point literal.  */
  270.  
  271. int
  272. fp_literal(op, mode)
  273.      rtx op;
  274.      enum machine_mode mode;
  275. {
  276.   return fp_literal_zero (op, mode) || fp_literal_one (op, mode);
  277. }
  278.  
  279. /* Return true if OP is a valid signed immediate constant.  */
  280.  
  281. int
  282. signed_literal(op, mode)
  283.      rtx op;
  284.      enum machine_mode mode;
  285. {
  286.   return ((GET_CODE (op) == CONST_INT) && INTVAL(op) > -32 && INTVAL(op) < 32);
  287. }
  288.  
  289. /* Return truth value of statement that OP is a symbolic memory
  290.    operand of mode MODE.  */
  291.  
  292. int
  293. symbolic_memory_operand (op, mode)
  294.      rtx op;
  295.      enum machine_mode mode;
  296. {
  297.   if (GET_CODE (op) == SUBREG)
  298.     op = SUBREG_REG (op);
  299.   if (GET_CODE (op) != MEM)
  300.     return 0;
  301.   op = XEXP (op, 0);
  302.   return (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == CONST
  303.       || GET_CODE (op) == HIGH || GET_CODE (op) == LABEL_REF);
  304. }
  305.  
  306. /* Return truth value of whether OP is EQ or NE.  */
  307.  
  308. int
  309. eq_or_neq (op, mode)
  310.      rtx op;
  311.      enum machine_mode mode;
  312. {
  313.   return (GET_CODE (op) == EQ || GET_CODE (op) == NE);
  314. }
  315.  
  316. /* OP is an integer register or a constant.  */
  317.  
  318. int
  319. arith32_operand (op, mode)
  320.      rtx op;
  321.      enum machine_mode mode;
  322. {
  323.   if (register_operand (op, mode))
  324.     return 1;
  325.   return (CONSTANT_P (op));
  326. }
  327.  
  328. /* Return true if OP is an integer constant which is a power of 2.  */
  329.  
  330. int
  331. power2_operand (op,mode)
  332.      rtx op;
  333.      enum machine_mode mode;
  334. {
  335.   if (GET_CODE (op) != CONST_INT)
  336.     return 0;
  337.  
  338.   return exact_log2 (INTVAL (op)) >= 0;
  339. }
  340.  
  341. /* Return true if OP is an integer constant which is the complement of a
  342.    power of 2.  */
  343.  
  344. int
  345. cmplpower2_operand (op, mode)
  346.      rtx op;
  347.      enum machine_mode mode;
  348. {
  349.   if (GET_CODE (op) != CONST_INT)
  350.     return 0;
  351.  
  352.   return exact_log2 (~ INTVAL (op)) >= 0;
  353. }
  354.  
  355. /* If VAL has only one bit set, return the index of that bit.  Otherwise
  356.    return -1.  */
  357.  
  358. int
  359. bitpos (val)
  360.      unsigned int val;
  361. {
  362.   register int i;
  363.  
  364.   for (i = 0; val != 0; i++, val >>= 1)
  365.     {
  366.       if (val & 1)
  367.     {
  368.       if (val != 1)
  369.         return -1;
  370.       return i;
  371.     }
  372.     }
  373.   return -1;
  374. }
  375.  
  376. /* Return non-zero if OP is a mask, i.e. all one bits are consecutive.
  377.    The return value indicates how many consecutive non-zero bits exist
  378.    if this is a mask.  This is the same as the next function, except that
  379.    it does not indicate what the start and stop bit positions are.  */
  380.  
  381. int
  382. is_mask (val)
  383.      unsigned int val;
  384. {
  385.   register int start, end, i;
  386.  
  387.   start = -1;
  388.   for (i = 0; val != 0; val >>= 1, i++)
  389.     {
  390.       if (val & 1)
  391.     {
  392.       if (start < 0)
  393.         start = i;
  394.  
  395.       end = i;
  396.       continue;
  397.     }
  398.       /* Still looking for the first bit.  */
  399.       if (start < 0)
  400.     continue;
  401.  
  402.       /* We've seen the start of a bit sequence, and now a zero.  There
  403.      must be more one bits, otherwise we would have exited the loop.
  404.      Therefore, it is not a mask.  */
  405.       if (val)
  406.     return 0;
  407.     }
  408.  
  409.   /* The bit string has ones from START to END bit positions only.  */
  410.   return end - start + 1;
  411. }
  412.  
  413. /* If VAL is a mask, then return nonzero, with S set to the starting bit
  414.    position and E set to the ending bit position of the mask.  The return
  415.    value indicates how many consecutive bits exist in the mask.  This is
  416.    the same as the previous function, except that it also indicates the
  417.    start and end bit positions of the mask.  */
  418.  
  419. int
  420. bitstr (val, s, e)
  421.      unsigned int val;
  422.      int *s, *e;
  423. {
  424.   register int start, end, i;
  425.  
  426.   start = -1;
  427.   end = -1;
  428.   for (i = 0; val != 0; val >>= 1, i++)
  429.     {
  430.       if (val & 1)
  431.     {
  432.       if (start < 0)
  433.         start = i;
  434.  
  435.       end = i;
  436.       continue;
  437.     }
  438.  
  439.       /* Still looking for the first bit.  */
  440.       if (start < 0)
  441.     continue;
  442.  
  443.       /* We've seen the start of a bit sequence, and now a zero.  There
  444.      must be more one bits, otherwise we would have exited the loop.
  445.      Therefor, it is not a mask.  */
  446.       if (val)
  447.     {
  448.       start = -1;
  449.       end = -1;
  450.       break;
  451.     }
  452.     }
  453.  
  454.   /* The bit string has ones from START to END bit positions only.  */
  455.   *s = start;
  456.   *e = end;
  457.   return ((start < 0) ? 0 : end - start + 1);
  458. }
  459.  
  460. /* Return the machine mode to use for a comparison.  */
  461.  
  462. enum machine_mode
  463. select_cc_mode (op, x)
  464.      RTX_CODE op;
  465.      rtx x;
  466. {
  467.   if (op == GTU || op == LTU || op == GEU || op == LEU)
  468.     return CC_UNSmode;
  469.   return CCmode;
  470. }
  471.  
  472. /* X and Y are two things to compare using CODE.  Emit the compare insn and
  473.    return the rtx for register 36 in the proper mode.  */
  474.  
  475. rtx
  476. gen_compare_reg (code, x, y)
  477.      enum rtx_code code;
  478.      rtx x, y;
  479. {
  480.   rtx cc_reg;
  481.   enum machine_mode ccmode = SELECT_CC_MODE (code, x, y);
  482.   enum machine_mode mode
  483.     = GET_MODE (x) == VOIDmode ? GET_MODE (y) : GET_MODE (x);
  484.  
  485.   if (mode == SImode)
  486.     {
  487.       if (! arith_operand (x, mode))
  488.     x = force_reg (SImode, x);
  489.       if (! arith_operand (y, mode))
  490.     y = force_reg (SImode, y);
  491.     }
  492.  
  493.   cc_reg = gen_rtx (REG, ccmode, 36);
  494.   emit_insn (gen_rtx (SET, VOIDmode, cc_reg,
  495.               gen_rtx (COMPARE, ccmode, x, y)));
  496.  
  497.   return cc_reg;
  498. }
  499.  
  500. /* For the i960, REG is cost 1, REG+immed CONST is cost 2, REG+REG is cost 2,
  501.    REG+nonimmed CONST is cost 4.  REG+SYMBOL_REF, SYMBOL_REF, and similar
  502.    are 4.  Indexed addresses are cost 6.  */
  503.  
  504. /* ??? Try using just RTX_COST, i.e. not defining ADDRESS_COST.  */
  505.  
  506. int
  507. i960_address_cost (x)
  508.      rtx x;
  509. {
  510. #if 0
  511.   /* Handled before calling here.  */
  512.   if (GET_CODE (x) == REG)
  513.     return 1;
  514. #endif
  515.   if (GET_CODE (x) == PLUS)
  516.     {
  517.       rtx base = XEXP (x, 0);
  518.       rtx offset = XEXP (x, 1);
  519.  
  520.       if (GET_CODE (base) == SUBREG)
  521.     base = SUBREG_REG (base);
  522.       if (GET_CODE (offset) == SUBREG)
  523.     offset = SUBREG_REG (offset);
  524.  
  525.       if (GET_CODE (base) == REG)
  526.     {
  527.       if (GET_CODE (offset) == REG)
  528.         return 2;
  529.       if (GET_CODE (offset) == CONST_INT)
  530.         {
  531.           if ((unsigned)INTVAL (offset) < 2047)
  532.         return 2;
  533.           return 4;
  534.         }
  535.       if (CONSTANT_P (offset))
  536.         return 4;
  537.     }
  538.       if (GET_CODE (base) == PLUS || GET_CODE (base) == MULT)
  539.     return 6;
  540.  
  541.       /* This is an invalid address.  The return value doesn't matter, but
  542.      for convenience we make this more expensive than anything else.  */
  543.       return 12;
  544.     }
  545.   if (GET_CODE (x) == MULT)
  546.     return 6;
  547.  
  548.   /* Symbol_refs and other unrecognized addresses are cost 4.  */
  549.   return 4;
  550. }
  551.  
  552. /* Emit insns to move operands[1] into operands[0].
  553.  
  554.    Return 1 if we have written out everything that needs to be done to
  555.    do the move.  Otherwise, return 0 and the caller will emit the move
  556.    normally.  */
  557.  
  558. int
  559. emit_move_sequence (operands, mode)
  560.      rtx *operands;
  561.      enum machine_mode mode;
  562. {
  563.   register rtx operand0 = operands[0];
  564.   register rtx operand1 = operands[1];
  565.  
  566.   /* We can only store registers to memory.  */
  567.  
  568.   if (GET_CODE (operand0) == MEM && GET_CODE (operand1) != REG)
  569.     operands[1] = force_reg (mode, operand1);
  570.  
  571.   return 0;
  572. }
  573.  
  574. /* Emit insns to load a constant to non-floating point registers.
  575.    Uses several strategies to try to use as few insns as possible.  */
  576.  
  577. char *
  578. i960_output_ldconst (dst, src)
  579.      register rtx dst, src;
  580. {
  581.   register int rsrc1;
  582.   register unsigned rsrc2;
  583.   enum machine_mode mode = GET_MODE (dst);
  584.   rtx operands[4];
  585.  
  586.   operands[0] = operands[2] = dst;
  587.   operands[1] = operands[3] = src;
  588.  
  589.   /* Anything that isn't a compile time constant, such as a SYMBOL_REF,
  590.      must be a ldconst insn.  */
  591.  
  592.   if (GET_CODE (src) != CONST_INT && GET_CODE (src) != CONST_DOUBLE)
  593.     {
  594.       output_asm_insn ("ldconst    %1,%0", operands);
  595.       return "";
  596.     }
  597.   else if (mode == XFmode)
  598.     {
  599.       REAL_VALUE_TYPE d;
  600.       long value_long[3];
  601.       int i;
  602.  
  603.       if (fp_literal_zero (src, XFmode))
  604.     return "movt    0,%0";
  605.  
  606.       REAL_VALUE_FROM_CONST_DOUBLE (d, src);
  607.       REAL_VALUE_TO_TARGET_LONG_DOUBLE (d, value_long);
  608.  
  609.       output_asm_insn ("# ldconst    %1,%0",operands);
  610.  
  611.       for (i = 0; i < 3; i++)
  612.     {
  613.       operands[0] = gen_rtx (REG, SImode, REGNO (dst) + i);
  614.       operands[1] = GEN_INT (value_long[i]);
  615.       output_asm_insn (i960_output_ldconst (operands[0], operands[1]),
  616.                operands);
  617.     }
  618.  
  619.       return ""; 
  620.    }
  621.   else if (mode == DFmode)
  622.     {
  623.       rtx first, second;
  624.  
  625.       if (fp_literal_zero (src, DFmode))
  626.     return "movl    0,%0";
  627.  
  628.       split_double (src, &first, &second);
  629.  
  630.       output_asm_insn ("# ldconst    %1,%0",operands);
  631.  
  632.       operands[0] = gen_rtx (REG, SImode, REGNO (dst));
  633.       operands[1] = first;
  634.       output_asm_insn (i960_output_ldconst (operands[0], operands[1]),
  635.               operands);
  636.       operands[0] = gen_rtx (REG, SImode, REGNO (dst) + 1);
  637.       operands[1] = second;
  638.       output_asm_insn (i960_output_ldconst (operands[0], operands[1]),
  639.               operands);
  640.       return "";
  641.     }
  642.   else if (mode == SFmode)
  643.     {
  644.       REAL_VALUE_TYPE d;
  645.       long value;
  646.  
  647.       REAL_VALUE_FROM_CONST_DOUBLE (d, src);
  648.       REAL_VALUE_TO_TARGET_SINGLE (d, value);
  649.  
  650.       output_asm_insn ("# ldconst    %1,%0",operands);
  651.       operands[0] = gen_rtx (REG, SImode, REGNO (dst));
  652.       operands[1] = gen_rtx (CONST_INT, VOIDmode, value);
  653.       output_asm_insn (i960_output_ldconst (operands[0], operands[1]),
  654.               operands);
  655.       return "";
  656.     }
  657.   else if (mode == TImode)
  658.     {
  659.       /* ??? This is currently not handled at all.  */
  660.       abort ();
  661.  
  662.       /* Note: lowest order word goes in lowest numbered reg.  */
  663.       rsrc1 = INTVAL (src);
  664.       if (rsrc1 >= 0 && rsrc1 < 32)
  665.     return "movq    %1,%0";
  666.       else
  667.     output_asm_insn ("movq\t0,%0\t# ldconstq %1,%0",operands);
  668.       /* Go pick up the low-order word.  */
  669.     }
  670.   else if (mode == DImode)
  671.     {
  672.       rtx upperhalf, lowerhalf, xoperands[2];
  673.  
  674.       if (GET_CODE (src) == CONST_DOUBLE || GET_CODE (src) == CONST_INT)
  675.      split_double (src, &lowerhalf, &upperhalf);
  676.  
  677.       else
  678.     abort ();
  679.  
  680.       /* Note: lowest order word goes in lowest numbered reg.  */
  681.       /* Numbers from 0 to 31 can be handled with a single insn.  */
  682.       rsrc1 = INTVAL (lowerhalf);
  683.       if (upperhalf == const0_rtx && rsrc1 >= 0 && rsrc1 < 32)
  684.     return "movl    %1,%0";
  685.  
  686.       /* Output the upper half with a recursive call.  */
  687.       xoperands[0] = gen_rtx (REG, SImode, REGNO (dst) + 1);
  688.       xoperands[1] = upperhalf;
  689.       output_asm_insn (i960_output_ldconst (xoperands[0], xoperands[1]),
  690.                xoperands);
  691.       /* The lower word is emitted as normally.  */
  692.     }
  693.   else
  694.     {
  695.       rsrc1 = INTVAL (src);
  696.       if (mode == QImode)
  697.     {
  698.       if (rsrc1 > 0xff)
  699.         rsrc1 &= 0xff;
  700.     }
  701.       else if (mode == HImode)
  702.     {
  703.       if (rsrc1 > 0xffff)
  704.         rsrc1 &= 0xffff;
  705.     }
  706.     }
  707.  
  708.   if (rsrc1 >= 0)
  709.     {
  710.       /* ldconst    0..31,X        ->     mov    0..31,X  */
  711.       if (rsrc1 < 32)
  712.     {
  713.       if (i960_last_insn_type == I_TYPE_REG && TARGET_C_SERIES)
  714.         return "lda    %1,%0";
  715.       return "mov    %1,%0";
  716.     }
  717.  
  718.       /* ldconst    32..63,X    ->    add    31,nn,X  */
  719.       if (rsrc1 < 63)
  720.     {
  721.       if (i960_last_insn_type == I_TYPE_REG && TARGET_C_SERIES)
  722.         return "lda    %1,%0";
  723.       operands[1] = gen_rtx (CONST_INT, VOIDmode, rsrc1 - 31);
  724.       output_asm_insn ("addo\t31,%1,%0\t# ldconst %3,%0", operands);
  725.       return "";
  726.     }
  727.     }
  728.   else if (rsrc1 < 0)
  729.     {
  730.       /* ldconst    -1..-31        ->    sub    0,0..31,X  */
  731.       if (rsrc1 >= -31)
  732.     {
  733.       /* return 'sub -(%1),0,%0' */
  734.       operands[1] = gen_rtx (CONST_INT, VOIDmode, - rsrc1);
  735.       output_asm_insn ("subo\t%1,0,%0\t# ldconst %3,%0", operands);
  736.       return "";
  737.     }
  738.       
  739.       /* ldconst    -32        ->    not    31,X  */
  740.       if (rsrc1 == -32)
  741.     {
  742.       operands[1] = gen_rtx (CONST_INT, VOIDmode, ~rsrc1);
  743.       output_asm_insn ("not\t%1,%0    # ldconst %3,%0", operands);
  744.       return "";
  745.     }
  746.     }
  747.  
  748.   /* If const is a single bit.  */
  749.   if (bitpos (rsrc1) >= 0)
  750.     {
  751.       operands[1] = gen_rtx (CONST_INT, VOIDmode, bitpos (rsrc1));
  752.       output_asm_insn ("setbit\t%1,0,%0\t# ldconst %3,%0", operands);
  753.       return "";
  754.     }
  755.  
  756.   /* If const is a bit string of less than 6 bits (1..31 shifted).  */
  757.   if (is_mask (rsrc1))
  758.     {
  759.       int s, e;
  760.  
  761.       if (bitstr (rsrc1, &s, &e) < 6)
  762.     {
  763.       rsrc2 = ((unsigned int) rsrc1) >> s;
  764.       operands[1] = gen_rtx (CONST_INT, VOIDmode, rsrc2);
  765.       operands[2] = gen_rtx (CONST_INT, VOIDmode, s);
  766.       output_asm_insn ("shlo\t%2,%1,%0\t# ldconst %3,%0", operands);
  767.       return "";
  768.     }
  769.     }
  770.  
  771.   /* Unimplemented cases:
  772.      const is in range 0..31 but rotated around end of word:
  773.      ror    31,3,g0    -> ldconst 0xe0000003,g0
  774.    
  775.      and any 2 instruction cases that might be worthwhile  */
  776.   
  777.   output_asm_insn ("ldconst    %1,%0", operands);
  778.   return "";
  779. }
  780.  
  781. /* Determine if there is an opportunity for a bypass optimization.
  782.    Bypass succeeds on the 960K* if the destination of the previous
  783.    instruction is the second operand of the current instruction.
  784.    Bypass always succeeds on the C*.
  785.  
  786.    Return 1 if the pattern should interchange the operands.
  787.  
  788.    CMPBR_FLAG is true if this is for a compare-and-branch insn.
  789.    OP1 and OP2 are the two source operands of a 3 operand insn.  */
  790.  
  791. int
  792. i960_bypass (insn, op1, op2, cmpbr_flag)
  793.      register rtx insn, op1, op2;
  794.      int cmpbr_flag;
  795. {
  796.   register rtx prev_insn, prev_dest;
  797.  
  798.   if (TARGET_C_SERIES)
  799.     return 0;
  800.  
  801.   /* Can't do this if op1 isn't a register.  */
  802.   if (! REG_P (op1))
  803.     return 0;
  804.  
  805.   /* Can't do this for a compare-and-branch if both ops aren't regs.  */
  806.   if (cmpbr_flag && ! REG_P (op2))
  807.     return 0;
  808.  
  809.   prev_insn = prev_real_insn (insn);
  810.  
  811.   if (prev_insn && GET_CODE (prev_insn) == INSN
  812.       && GET_CODE (PATTERN (prev_insn)) == SET)
  813.     {
  814.       prev_dest = SET_DEST (PATTERN (prev_insn));
  815.       if ((GET_CODE (prev_dest) == REG && REGNO (prev_dest) == REGNO (op1))
  816.       || (GET_CODE (prev_dest) == SUBREG
  817.           && GET_CODE (SUBREG_REG (prev_dest)) == REG
  818.           && REGNO (SUBREG_REG (prev_dest)) == REGNO (op1)))
  819.     return 1;
  820.     }
  821.   return 0;
  822. }
  823.  
  824. /* Output the code which declares the function name.  This also handles
  825.    leaf routines, which have special requirements, and initializes some
  826.    global variables.  */
  827.  
  828. void
  829. i960_function_name_declare (file, name, fndecl)
  830.      FILE *file;
  831.      char *name;
  832.      tree fndecl;
  833. {
  834.   register int i, j;
  835.   int leaf_proc_ok;
  836.   rtx insn;
  837.  
  838.   /* Increment global return label.  */
  839.  
  840.   ret_label++;
  841.  
  842.   /* Compute whether tail calls and leaf routine optimizations can be performed
  843.      for this function.  */
  844.  
  845.   if (TARGET_TAILCALL)
  846.     tail_call_ok = 1;
  847.   else
  848.     tail_call_ok = 0;
  849.  
  850.   if (TARGET_LEAFPROC)
  851.     leaf_proc_ok = 1;
  852.   else
  853.     leaf_proc_ok = 0;
  854.  
  855.   /* Even if nobody uses extra parms, can't have leafproc or tail calls if
  856.      argblock, because argblock uses g14 implicitly.  */
  857.  
  858.   if (current_function_args_size != 0 || VARARGS_STDARG_FUNCTION (fndecl))
  859.     {
  860.       tail_call_ok = 0;
  861.       leaf_proc_ok = 0;
  862.     }
  863.       
  864.   /* See if caller passes in an address to return value. */
  865.  
  866.   if (aggregate_value_p (DECL_RESULT (fndecl)))
  867.     {
  868.       tail_call_ok = 0;
  869.       leaf_proc_ok = 0;
  870.     }
  871.  
  872.   /* Can not use tail calls or make this a leaf routine if there is a non
  873.      zero frame size.  */
  874.  
  875.   if (get_frame_size () != 0)
  876.     leaf_proc_ok = 0;
  877.  
  878.   /* I don't understand this condition, and do not think that it is correct.
  879.      Apparently this is just checking whether the frame pointer is used, and
  880.      we can't trust regs_ever_live[fp] since it is (almost?) always set.  */
  881.  
  882.   if (tail_call_ok)
  883.     for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
  884.       if (GET_CODE (insn) == INSN
  885.       && reg_mentioned_p (frame_pointer_rtx, insn))
  886.     {
  887.       tail_call_ok = 0;
  888.       break;
  889.     }
  890.  
  891.   /* Check for CALL insns.  Can not be a leaf routine if there are any.  */
  892.  
  893.   if (leaf_proc_ok)
  894.     for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
  895.       if (GET_CODE (insn) == CALL_INSN)
  896.     {
  897.       leaf_proc_ok = 0;
  898.       break;
  899.     }
  900.  
  901.   /* Can not be a leaf routine if any non-call clobbered registers are
  902.      used in this function.  */
  903.  
  904.   if (leaf_proc_ok)
  905.     for (i = 0, j = 0; i < FIRST_PSEUDO_REGISTER; i++)
  906.       if (regs_ever_live[i]
  907.       && ((! call_used_regs[i]) || (i > 7 && i < 12)))
  908.     {
  909.       /* Global registers.  */
  910.       if (i < 16 && i > 7 && i != 13)
  911.         leaf_proc_ok = 0;
  912.       /* Local registers.  */
  913.       else if (i < 32)
  914.         leaf_proc_ok = 0;
  915.     }
  916.  
  917.   /* Now choose a leaf return register, if we can find one, and if it is
  918.      OK for this to be a leaf routine.  */
  919.  
  920.   i960_leaf_ret_reg = -1;
  921.  
  922.   if (optimize && leaf_proc_ok)
  923.     {
  924.       for (i960_leaf_ret_reg = -1, i = 0; i < 8; i++)
  925.     if (regs_ever_live[i] == 0)
  926.       {
  927.         i960_leaf_ret_reg = i;
  928.         regs_ever_live[i] = 1;
  929.         break;
  930.       }
  931.     }
  932.  
  933.   /* Do this after choosing the leaf return register, so it will be listed
  934.      if one was chosen.  */
  935.  
  936.   fprintf (file, "\t#  Function '%s'\n", (name[0] == '*' ? &name[1] : name));
  937.   fprintf (file, "\t#  Registers used: ");
  938.  
  939.   for (i = 0, j = 0; i < FIRST_PSEUDO_REGISTER; i++)
  940.     {
  941.       if (regs_ever_live[i])
  942.     {
  943.       fprintf (file, "%s%s ", reg_names[i], call_used_regs[i] ? "" : "*");
  944.  
  945.       if (i > 15 && j == 0)
  946.         {
  947.           fprintf (file,"\n\t#\t\t   ");
  948.           j++;
  949.             }
  950.         }
  951.     }
  952.  
  953.   fprintf (file, "\n");
  954.  
  955.   if (i960_leaf_ret_reg >= 0)
  956.     {
  957.       /* Make it a leaf procedure.  */
  958.  
  959.       if (TREE_PUBLIC (fndecl))
  960.     fprintf (file,"\t.globl\t%s.lf\n", (name[0] == '*' ? &name[1] : name));
  961.  
  962.       fprintf (file, "\t.leafproc\t");
  963.       assemble_name (file, name);
  964.       fprintf (file, ",%s.lf\n", (name[0] == '*' ? &name[1] : name));
  965.       ASM_OUTPUT_LABEL (file, name);
  966.       fprintf (file, "\tlda    LR%d,g14\n", ret_label);
  967.       fprintf (file, "%s.lf:\n", (name[0] == '*' ? &name[1] : name));
  968.       fprintf (file, "\tmov    g14,g%d\n", i960_leaf_ret_reg);
  969.  
  970.       if (TARGET_C_SERIES)
  971.     {
  972.       fprintf (file, "\tlda    0,g14\n");
  973.       i960_last_insn_type = I_TYPE_MEM;
  974.     }
  975.       else
  976.     {
  977.       fprintf (file, "\tmov    0,g14\n");
  978.       i960_last_insn_type = I_TYPE_REG;
  979.     }
  980.     }
  981.   else
  982.     {
  983.       ASM_OUTPUT_LABEL (file, name);
  984.       i960_last_insn_type = I_TYPE_CTRL; 
  985.     }
  986. }
  987.  
  988. /* Compute and return the frame size.  */
  989.  
  990. int
  991. compute_frame_size (size)
  992.      int size;
  993. {
  994.   int actual_fsize;
  995.   int outgoing_args_size = current_function_outgoing_args_size;
  996.  
  997.   /* The STARTING_FRAME_OFFSET is totally hidden to us as far
  998.      as size is concerned.  */
  999.   actual_fsize = (size + 15) & -16;
  1000.   actual_fsize += (outgoing_args_size + 15) & -16;
  1001.  
  1002.   return actual_fsize;
  1003. }
  1004.  
  1005. /* Output code for the function prologue.  */
  1006.  
  1007. void
  1008. i960_function_prologue (file, size)
  1009.      FILE *file;
  1010.      unsigned int size;
  1011. {
  1012.   register int i, j, nr;
  1013.   int n_iregs = 0;
  1014.   int rsize = 0;
  1015.   int actual_fsize, offset;
  1016.   char tmpstr[1000];
  1017.   /* -1 if reg must be saved on proc entry, 0 if available, 1 if saved
  1018.      somewhere.  */
  1019.   int regs[FIRST_PSEUDO_REGISTER];
  1020.  
  1021.   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
  1022.     if (regs_ever_live[i]
  1023.     && ((! call_used_regs[i]) || (i > 7 && i < 12)))
  1024.       {
  1025.     regs[i] = -1;
  1026.         /* Count global registers that need saving.  */
  1027.     if (i < 16)
  1028.       n_iregs++;
  1029.       }
  1030.     else
  1031.       regs[i] = 0;
  1032.  
  1033.   epilogue_string[0] = '\0';
  1034.  
  1035.   if (profile_flag || profile_block_flag)
  1036.     {
  1037.       /* When profiling, we may use registers 20 to 27 to save arguments, so
  1038.      they can't be used here for saving globals.  J is the number of
  1039.      argument registers the mcount call will save.  */
  1040.       for (j = 7; j >= 0 && ! regs_ever_live[j]; j--)
  1041.     ;
  1042.  
  1043.       for (i = 20; i <= j + 20; i++)
  1044.     regs[i] = -1;
  1045.     }
  1046.  
  1047.   /* First look for local registers to save globals in.  */
  1048.   for (i = 0; i < 16; i++)
  1049.     {
  1050.       if (regs[i] == 0)
  1051.     continue;
  1052.  
  1053.       /* Start at r4, not r3.  */
  1054.       for (j = 20; j < 32; j++)
  1055.     {
  1056.       if (regs[j] != 0)
  1057.         continue;
  1058.  
  1059.       regs[i] = 1;
  1060.       regs[j] = -1;
  1061.       regs_ever_live[j] = 1;
  1062.       nr = 1;
  1063.       if (i <= 14 && i % 2 == 0 && j <= 30 && j % 2 == 0
  1064.           && regs[i+1] != 0 && regs[j+1] == 0)
  1065.         {
  1066.           nr = 2;
  1067.           regs[i+1] = 1;
  1068.           regs[j+1] = -1;
  1069.           regs_ever_live[j+1] = 1;
  1070.         }
  1071.       if (nr == 2 && i <= 12 && i % 4 == 0 && j <= 28 && j % 4 == 0
  1072.           && regs[i+2] != 0 && regs[j+2] == 0)
  1073.         {
  1074.           nr = 3;
  1075.           regs[i+2] = 1;
  1076.           regs[j+2] = -1;
  1077.           regs_ever_live[j+2] = 1;
  1078.         }
  1079.       if (nr == 3 && regs[i+3] != 0 && regs[j+3] == 0)
  1080.         {
  1081.           nr = 4;
  1082.           regs[i+3] = 1;
  1083.           regs[j+3] = -1;
  1084.           regs_ever_live[j+3] = 1;
  1085.         }
  1086.  
  1087.       fprintf (file, "\tmov%s    %s,%s\n",
  1088.            ((nr == 4) ? "q" :
  1089.             (nr == 3) ? "t" :
  1090.             (nr == 2) ? "l" : ""),
  1091.            reg_names[i], reg_names[j]);
  1092.       sprintf (tmpstr, "\tmov%s    %s,%s\n",
  1093.            ((nr == 4) ? "q" :
  1094.             (nr == 3) ? "t" :
  1095.             (nr == 2) ? "l" : ""),
  1096.            reg_names[j], reg_names[i]);
  1097.       strcat (epilogue_string, tmpstr);
  1098.  
  1099.       n_iregs -= nr;
  1100.       i += nr-1;
  1101.       break;
  1102.     }
  1103.     }
  1104.  
  1105.   /* N_iregs is now the number of global registers that haven't been saved
  1106.      yet.  */
  1107.  
  1108.   rsize = (n_iregs * 4);
  1109.   actual_fsize = compute_frame_size (size) + rsize;
  1110. #if 0
  1111.   /* ??? The 1.2.1 compiler does this also.  This is meant to round the frame
  1112.      size up to the nearest multiple of 16.  I don't know whether this is
  1113.      necessary, or even desirable.
  1114.  
  1115.      The frame pointer must be aligned, but the call instruction takes care of
  1116.      that.  If we leave the stack pointer unaligned, we may save a little on
  1117.      dynamic stack allocation.  And we don't lose, at least according to the
  1118.      i960CA manual.  */
  1119.   actual_fsize = (actual_fsize + 15) & ~0xF;
  1120. #endif
  1121.  
  1122.   /* Allocate space for register save and locals.  */
  1123.   if (actual_fsize > 0)
  1124.     {
  1125.       if (actual_fsize < 32)
  1126.     fprintf (file, "\taddo    %d,sp,sp\n", actual_fsize);
  1127.       else
  1128.     fprintf (file, "\tlda\t%d(sp),sp\n", actual_fsize);
  1129.     }
  1130.  
  1131.   /* Take hardware register save area created by the call instruction
  1132.      into account, but store them before the argument block area.  */
  1133.   offset = 64 + actual_fsize - compute_frame_size (0) - rsize;
  1134.   /* Save registers on stack if needed.  */
  1135.   for (i = 0, j = n_iregs; j > 0 && i < 16; i++)
  1136.     {
  1137.       if (regs[i] != -1)
  1138.     continue;
  1139.  
  1140.       nr = 1;
  1141.  
  1142.       if (i <= 14 && i % 2 == 0 && regs[i+1] == -1 && offset % 2 == 0)
  1143.     nr = 2;
  1144.  
  1145.       if (nr == 2 && i <= 12 && i % 4 == 0 && regs[i+2] == -1
  1146.       && offset % 4 == 0)
  1147.     nr = 3;
  1148.  
  1149.       if (nr == 3 && regs[i+3] == -1)
  1150.     nr = 4;
  1151.  
  1152.       fprintf (file,"\tst%s    %s,%d(fp)\n",
  1153.            ((nr == 4) ? "q" :
  1154.         (nr == 3) ? "t" :
  1155.         (nr == 2) ? "l" : ""),
  1156.            reg_names[i], offset);
  1157.       sprintf (tmpstr,"\tld%s    %d(fp),%s\n",
  1158.            ((nr == 4) ? "q" :
  1159.         (nr == 3) ? "t" :
  1160.         (nr == 2) ? "l" : ""),
  1161.            offset, reg_names[i]);
  1162.       strcat (epilogue_string, tmpstr);
  1163.       i += nr-1;
  1164.       j -= nr;
  1165.       offset += nr * 4;
  1166.     }
  1167.  
  1168.   if (actual_fsize == 0 && size == 0 && rsize == 0)
  1169.     return;
  1170.  
  1171.   fprintf (file, "\t#Prologue stats:\n");
  1172.   fprintf (file, "\t#  Total Frame Size: %d bytes\n", actual_fsize);
  1173.  
  1174.   if (size)
  1175.     fprintf (file, "\t#  Local Variable Size: %d bytes\n", size);
  1176.   if (rsize)
  1177.     fprintf (file, "\t#  Register Save Size: %d regs, %d bytes\n",
  1178.          n_iregs, rsize);
  1179.   fprintf (file, "\t#End Prologue#\n");
  1180. }
  1181.  
  1182. /* Output code for the function profiler.  */
  1183.  
  1184. void
  1185. output_function_profiler (file, labelno)
  1186.      FILE *file;
  1187.      int labelno;
  1188. {
  1189.   /* The last used parameter register.  */
  1190.   int last_parm_reg;
  1191.   int i, j, increment;
  1192.   int varargs_stdarg_function
  1193.     = VARARGS_STDARG_FUNCTION (current_function_decl);
  1194.  
  1195.   /* Figure out the last used parameter register.  The proper thing to do
  1196.      is to walk incoming args of the function.  A function might have live
  1197.      parameter registers even if it has no incoming args.  Note that we
  1198.      don't have to save parameter registers g8 to g11 because they are
  1199.      call preserved.  */
  1200.  
  1201.   /* See also output_function_prologue, which tries to use local registers
  1202.      for preserved call-saved global registers.  */
  1203.  
  1204.   for (last_parm_reg = 7;
  1205.        last_parm_reg >= 0 && ! regs_ever_live[last_parm_reg];
  1206.        last_parm_reg--)
  1207.     ;
  1208.  
  1209.   /* Save parameter registers in regs r4 (20) to r11 (27).  */
  1210.  
  1211.   for (i = 0, j = 4; i <= last_parm_reg; i += increment, j += increment)
  1212.     {
  1213.       if (i % 4 == 0 && (last_parm_reg - i) >= 3)
  1214.     increment = 4;
  1215.       else if (i % 4 == 0 && (last_parm_reg - i) >= 2)
  1216.     increment = 3;
  1217.       else if (i % 2 == 0 && (last_parm_reg - i) >= 1)
  1218.     increment = 2;
  1219.       else
  1220.     increment = 1;
  1221.  
  1222.       fprintf (file, "\tmov%s    g%d,r%d\n",
  1223.            (increment == 4 ? "q" : increment == 3 ? "t"
  1224.         : increment == 2 ? "l": ""), i, j);
  1225.       }
  1226.  
  1227.   /* If this function uses the arg pointer, then save it in r3 and then
  1228.      set it to zero.  */
  1229.  
  1230.   if (current_function_args_size != 0 || varargs_stdarg_function)
  1231.     fprintf (file, "\tmov    g14,r3\n\tmov    0,g14\n");
  1232.  
  1233.   /* Load location address into g0 and call mcount.  */
  1234.  
  1235.   fprintf (file, "\tlda\tLP%d,g0\n\tcallx\tmcount\n", labelno);
  1236.  
  1237.   /* If this function uses the arg pointer, restore it.  */
  1238.  
  1239.   if (current_function_args_size != 0 || varargs_stdarg_function)
  1240.     fprintf (file, "\tmov    r3,g14\n");
  1241.  
  1242.   /* Restore parameter registers.  */
  1243.  
  1244.   for (i = 0, j = 4; i <= last_parm_reg; i += increment, j += increment)
  1245.     {
  1246.       if (i % 4 == 0 && (last_parm_reg - i) >= 3)
  1247.     increment = 4;
  1248.       else if (i % 4 == 0 && (last_parm_reg - i) >= 2)
  1249.     increment = 3;
  1250.       else if (i % 2 == 0 && (last_parm_reg - i) >= 1)
  1251.     increment = 2;
  1252.       else
  1253.     increment = 1;
  1254.  
  1255.       fprintf (file, "\tmov%s    r%d,g%d\n",
  1256.            (increment == 4 ? "q" : increment == 3 ? "t"
  1257.         : increment == 2 ? "l": ""), j, i);
  1258.     }
  1259. }
  1260.  
  1261. /* Output code for the function epilogue.  */
  1262.  
  1263. void
  1264. i960_function_epilogue (file, size)
  1265.      FILE *file;
  1266.      unsigned int size;
  1267. {
  1268.   if (i960_leaf_ret_reg >= 0)
  1269.     {
  1270.       fprintf (file, "LR%d:    ret\n", ret_label);
  1271.       return;
  1272.     }
  1273.  
  1274.   if (*epilogue_string == 0)
  1275.     {
  1276.       register rtx tmp;
  1277.     
  1278.       /* Emit a return insn, but only if control can fall through to here.  */
  1279.  
  1280.       tmp = get_last_insn ();
  1281.       while (tmp)
  1282.     {
  1283.       if (GET_CODE (tmp) == BARRIER)
  1284.         return;
  1285.       if (GET_CODE (tmp) == CODE_LABEL)
  1286.         break;
  1287.       if (GET_CODE (tmp) == JUMP_INSN)
  1288.         {
  1289.           if (GET_CODE (PATTERN (tmp)) == RETURN)
  1290.         return;
  1291.           break;
  1292.         }
  1293.       if (GET_CODE (tmp) == NOTE)
  1294.         {
  1295.           tmp = PREV_INSN (tmp);
  1296.           continue;
  1297.         }
  1298.       break;
  1299.     }
  1300.       fprintf (file, "LR%d:    ret\n", ret_label);
  1301.       return;
  1302.     }
  1303.  
  1304.   fprintf (file, "LR%d:\n", ret_label);
  1305.  
  1306.   fprintf (file, "\t#EPILOGUE#\n");
  1307.  
  1308.   /* Output the string created by the prologue which will restore all
  1309.      registers saved by the prologue.  */
  1310.  
  1311.   if (epilogue_string[0] != '\0')
  1312.     fprintf (file, "%s", epilogue_string);
  1313.  
  1314.   /* Must clear g14 on return.  */
  1315.  
  1316.   if (current_function_args_size != 0
  1317.       || VARARGS_STDARG_FUNCTION (current_function_decl))
  1318.     fprintf (file, "\tmov    0,g14\n");
  1319.  
  1320.   fprintf (file, "\tret\n");
  1321.   fprintf (file, "\t#End Epilogue#\n");
  1322. }
  1323.  
  1324. /* Output code for a call insn.  */
  1325.  
  1326. char *
  1327. i960_output_call_insn (target, argsize_rtx, arg_pointer, insn)
  1328.      register rtx target, argsize_rtx, arg_pointer, insn;
  1329. {
  1330.   int argsize = INTVAL (argsize_rtx);
  1331.   rtx nexti = next_real_insn (insn);
  1332.   rtx operands[2];
  1333.   int varargs_stdarg_function
  1334.     = VARARGS_STDARG_FUNCTION (current_function_decl);
  1335.  
  1336.   operands[0] = target;
  1337.   operands[1] = arg_pointer;
  1338.  
  1339.   if (current_function_args_size != 0 || varargs_stdarg_function)
  1340.     output_asm_insn ("mov    g14,r3", operands);
  1341.  
  1342.   if (argsize > 48)
  1343.     output_asm_insn ("lda    %a1,g14", operands);
  1344.   else if (current_function_args_size != 0 || varargs_stdarg_function)
  1345.     output_asm_insn ("mov    0,g14", operands);
  1346.  
  1347.   /* The code used to assume that calls to SYMBOL_REFs could not be more
  1348.      than 24 bits away (b vs bx, callj vs callx).  This is not true.  This
  1349.      feature is now implemented by relaxing in the GNU linker.  It can convert
  1350.      bx to b if in range, and callx to calls/call/balx/bal as appropriate.  */
  1351.  
  1352.   /* Nexti could be zero if the called routine is volatile.  */
  1353.   if (optimize && (*epilogue_string == 0) && argsize == 0 && tail_call_ok 
  1354.       && (nexti == 0 || GET_CODE (PATTERN (nexti)) == RETURN))
  1355.     {
  1356.       /* Delete following return insn.  */
  1357.       if (nexti && no_labels_between_p (insn, nexti))
  1358.     delete_insn (nexti);
  1359.       output_asm_insn ("bx    %0", operands);
  1360.       return "# notreached";
  1361.     }
  1362.  
  1363.   output_asm_insn ("callx    %0", operands);
  1364.  
  1365.   if (current_function_args_size != 0 || varargs_stdarg_function)
  1366.     output_asm_insn ("mov    r3,g14", operands);
  1367.  
  1368.   return "";
  1369. }
  1370.  
  1371. /* Output code for a return insn.  */
  1372.  
  1373. char *
  1374. i960_output_ret_insn (insn)
  1375.      register rtx insn;
  1376. {
  1377.   static char lbuf[20];
  1378.   
  1379.   if (*epilogue_string != 0)
  1380.     {
  1381.       if (! TARGET_CODE_ALIGN && next_real_insn (insn) == 0)
  1382.     return "";
  1383.  
  1384.       sprintf (lbuf, "b    LR%d", ret_label);
  1385.       return lbuf;
  1386.     }
  1387.  
  1388.   if (current_function_args_size != 0
  1389.       || VARARGS_STDARG_FUNCTION (current_function_decl))
  1390.     output_asm_insn ("mov    0,g14", 0);
  1391.  
  1392.   if (i960_leaf_ret_reg >= 0)
  1393.     {
  1394.       sprintf (lbuf, "bx    (%s)", reg_names[i960_leaf_ret_reg]);
  1395.       return lbuf;
  1396.     }
  1397.   return "ret";
  1398. }
  1399.  
  1400. #if 0
  1401. /* Return a character string representing the branch prediction
  1402.    opcode to be tacked on an instruction.  This must at least
  1403.    return a null string.  */
  1404.  
  1405. char *
  1406. i960_br_predict_opcode (lab_ref, insn)
  1407.      rtx lab_ref, insn;
  1408. {
  1409.   if (TARGET_BRANCH_PREDICT)
  1410.     {
  1411.       unsigned long label_uid;
  1412.       
  1413.       if (GET_CODE (lab_ref) == CODE_LABEL)
  1414.     label_uid = INSN_UID (lab_ref);
  1415.       else if (GET_CODE (lab_ref) == LABEL_REF)
  1416.     label_uid = INSN_UID (XEXP (lab_ref, 0));
  1417.       else
  1418.     return ".f";
  1419.  
  1420.       /* If not optimizing, then the insn_addresses array will not be
  1421.      valid.  In this case, always return ".t" since most branches
  1422.      are taken.  If optimizing, return .t for backward branches
  1423.      and .f for forward branches.  */
  1424.       if (! optimize
  1425.       || insn_addresses[label_uid] < insn_addresses[INSN_UID (insn)])
  1426.     return ".t";
  1427.       return ".f";
  1428.     }
  1429.     
  1430.   return "";
  1431. }
  1432. #endif
  1433.  
  1434. /* Print the operand represented by rtx X formatted by code CODE.  */
  1435.  
  1436. void
  1437. i960_print_operand (file, x, code)
  1438.      FILE *file;
  1439.      rtx x;
  1440.      char code;
  1441. {
  1442.   enum rtx_code rtxcode = GET_CODE (x);
  1443.  
  1444.   if (rtxcode == REG)
  1445.     {
  1446.       switch (code)
  1447.     {
  1448.     case 'D':
  1449.       /* Second reg of a double.  */
  1450.       fprintf (file, "%s", reg_names[REGNO (x)+1]);
  1451.       break;
  1452.  
  1453.     case 0:
  1454.       fprintf (file, "%s", reg_names[REGNO (x)]);
  1455.       break;
  1456.  
  1457.     default:
  1458.       abort ();
  1459.     }
  1460.       return;
  1461.     }
  1462.   else if (rtxcode == MEM)
  1463.     {
  1464.       output_address (XEXP (x, 0));
  1465.       return;
  1466.     }
  1467.   else if (rtxcode == CONST_INT)
  1468.     {
  1469.       if (INTVAL (x) > 9999 || INTVAL (x) < -999)
  1470.     fprintf (file, "0x%x", INTVAL (x));
  1471.       else
  1472.     fprintf (file, "%d", INTVAL (x));
  1473.       return;
  1474.     }
  1475.   else if (rtxcode == CONST_DOUBLE)
  1476.     {
  1477.       REAL_VALUE_TYPE d;
  1478.       char dstr[30];
  1479.  
  1480.       if (x == CONST0_RTX (GET_MODE (x)))
  1481.     {
  1482.       fprintf (file, "0f0.0");
  1483.       return;
  1484.     }
  1485.       else if (x == CONST1_RTX (GET_MODE (x)))
  1486.     {
  1487.       fprintf (file, "0f1.0");
  1488.       return;
  1489.     }
  1490.  
  1491.       REAL_VALUE_FROM_CONST_DOUBLE (d, x);
  1492.       REAL_VALUE_TO_DECIMAL (d, "%#g", dstr);
  1493.       fprintf (file, "0f%s", dstr);
  1494.       return;
  1495.     }
  1496.  
  1497.   switch(code)
  1498.     {
  1499.     case 'B':
  1500.       /* Branch or jump, depending on assembler.  */
  1501.       if (TARGET_ASM_COMPAT)
  1502.     fputs ("j", file);
  1503.       else
  1504.     fputs ("b", file);
  1505.       break;
  1506.  
  1507.     case 'S':
  1508.       /* Sign of condition.  */
  1509.       if ((rtxcode == EQ) || (rtxcode == NE) || (rtxcode == GTU)
  1510.       || (rtxcode == LTU) || (rtxcode == GEU) || (rtxcode == LEU))
  1511.     fputs ("o", file);
  1512.       else if ((rtxcode == GT) || (rtxcode == LT)
  1513.       || (rtxcode == GE) || (rtxcode == LE))
  1514.     fputs ("i", file);
  1515.       else
  1516.     abort();
  1517.       break;
  1518.  
  1519.     case 'I':
  1520.       /* Inverted condition.  */
  1521.       rtxcode = reverse_condition (rtxcode);
  1522.       goto normal;
  1523.  
  1524.     case 'X':
  1525.       /* Inverted condition w/ reversed operands.  */
  1526.       rtxcode = reverse_condition (rtxcode);
  1527.       /* Fallthrough.  */
  1528.  
  1529.     case 'R':
  1530.       /* Reversed operand condition.  */
  1531.       rtxcode = swap_condition (rtxcode);
  1532.       /* Fallthrough.  */
  1533.  
  1534.     case 'C':
  1535.       /* Normal condition.  */
  1536.     normal:
  1537.       if (rtxcode == EQ)  { fputs ("e", file); return; }
  1538.       else if (rtxcode == NE)  { fputs ("ne", file); return; }
  1539.       else if (rtxcode == GT)  { fputs ("g", file); return; }
  1540.       else if (rtxcode == GTU) { fputs ("g", file); return; }
  1541.       else if (rtxcode == LT)  { fputs ("l", file); return; }
  1542.       else if (rtxcode == LTU) { fputs ("l", file); return; }
  1543.       else if (rtxcode == GE)  { fputs ("ge", file); return; }
  1544.       else if (rtxcode == GEU) { fputs ("ge", file); return; }
  1545.       else if (rtxcode == LE)  { fputs ("le", file); return; }
  1546.       else if (rtxcode == LEU) { fputs ("le", file); return; }
  1547.       else abort ();
  1548.       break;
  1549.  
  1550.     case 0:
  1551.       output_addr_const (file, x);
  1552.       break;
  1553.  
  1554.     default:
  1555.       abort ();
  1556.     }
  1557.  
  1558.   return;
  1559. }
  1560.  
  1561. /* Print a memory address as an operand to reference that memory location.
  1562.  
  1563.    This is exactly the same as legitimate_address_p, except that it the prints
  1564.    addresses instead of recognizing them.  */
  1565.  
  1566. void
  1567. i960_print_operand_addr (file, addr)
  1568.      FILE *file;
  1569.      register rtx addr;
  1570. {
  1571.   rtx breg, ireg;
  1572.   rtx scale, offset;
  1573.  
  1574.   ireg = 0;
  1575.   breg = 0;
  1576.   offset = 0;
  1577.   scale = const1_rtx;
  1578.  
  1579.   if (GET_CODE (addr) == REG)
  1580.     breg = addr;
  1581.   else if (CONSTANT_P (addr))
  1582.     offset = addr;
  1583.   else if (GET_CODE (addr) == PLUS)
  1584.     {
  1585.       rtx op0, op1;
  1586.  
  1587.       op0 = XEXP (addr, 0);
  1588.       op1 = XEXP (addr, 1);
  1589.  
  1590.       if (GET_CODE (op0) == REG)
  1591.     {
  1592.       breg = op0;
  1593.       if (GET_CODE (op1) == REG)
  1594.         ireg = op1;
  1595.       else if (CONSTANT_P (op1))
  1596.         offset = op1;
  1597.       else
  1598.         abort ();
  1599.     }
  1600.       else if (GET_CODE (op0) == PLUS)
  1601.     {
  1602.       if (GET_CODE (XEXP (op0, 0)) == MULT)
  1603.         {
  1604.           ireg = XEXP (XEXP (op0, 0), 0);
  1605.           scale = XEXP (XEXP (op0, 0), 1);
  1606.           if (GET_CODE (XEXP (op0, 1)) == REG)
  1607.         {
  1608.           breg = XEXP (op0, 1);
  1609.           offset = op1;
  1610.         }
  1611.           else
  1612.         abort ();
  1613.         }
  1614.       else if (GET_CODE (XEXP (op0, 0)) == REG)
  1615.         {
  1616.           breg = XEXP (op0, 0);
  1617.           if (GET_CODE (XEXP (op0, 1)) == REG)
  1618.         {
  1619.           ireg = XEXP (op0, 1);
  1620.           offset = op1;
  1621.         }
  1622.           else
  1623.         abort ();
  1624.         }
  1625.       else
  1626.         abort ();
  1627.     }
  1628.       else if (GET_CODE (op0) == MULT)
  1629.     {
  1630.       ireg = XEXP (op0, 0);
  1631.       scale = XEXP (op0, 1);
  1632.       if (GET_CODE (op1) == REG)
  1633.         breg = op1;
  1634.       else if (CONSTANT_P (op1))
  1635.         offset = op1;
  1636.       else
  1637.         abort ();
  1638.     }
  1639.       else
  1640.     abort ();
  1641.     }
  1642.   else if (GET_CODE (addr) == MULT)
  1643.     {
  1644.       ireg = XEXP (addr, 0);
  1645.       scale = XEXP (addr, 1);
  1646.     }
  1647.   else
  1648.     abort ();
  1649.  
  1650.   if (offset)
  1651.     output_addr_const (file, offset);
  1652.   if (breg)
  1653.     fprintf (file, "(%s)", reg_names[REGNO (breg)]);
  1654.   if (ireg)
  1655.     fprintf (file, "[%s*%d]", reg_names[REGNO (ireg)], INTVAL (scale));
  1656. }
  1657.  
  1658. /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
  1659.    that is a valid memory address for an instruction.
  1660.    The MODE argument is the machine mode for the MEM expression
  1661.    that wants to use this address.
  1662.  
  1663.     On 80960, legitimate addresses are:
  1664.         base                ld    (g0),r0
  1665.         disp    (12 or 32 bit)        ld    foo,r0
  1666.         base + index            ld    (g0)[g1*1],r0
  1667.         base + displ            ld    0xf00(g0),r0
  1668.         base + index*scale + displ    ld    0xf00(g0)[g1*4],r0
  1669.         index*scale + base        ld    (g0)[g1*4],r0
  1670.         index*scale + displ        ld    0xf00[g1*4],r0
  1671.         index*scale            ld    [g1*4],r0
  1672.         index + base + displ        ld    0xf00(g0)[g1*1],r0
  1673.  
  1674.     In each case, scale can be 1, 2, 4, 8, or 16.  */
  1675.  
  1676. /* This is exactly the same as i960_print_operand_addr, except that
  1677.    it recognizes addresses instead of printing them.
  1678.  
  1679.    It only recognizes address in canonical form.  LEGITIMIZE_ADDRESS should
  1680.    convert common non-canonical forms to canonical form so that they will
  1681.    be recognized.  */
  1682.  
  1683. /* These two macros allow us to accept either a REG or a SUBREG anyplace
  1684.    where a register is valid.  */
  1685.  
  1686. #define RTX_OK_FOR_BASE_P(X, STRICT)                    \
  1687.   ((GET_CODE (X) == REG                            \
  1688.     && (STRICT ? REG_OK_FOR_BASE_P_STRICT (X) : REG_OK_FOR_BASE_P (X)))    \
  1689.    || (GET_CODE (X) == SUBREG                        \
  1690.        && GET_CODE (SUBREG_REG (X)) == REG                \
  1691.        && (STRICT ? REG_OK_FOR_BASE_P_STRICT (SUBREG_REG (X))        \
  1692.        : REG_OK_FOR_BASE_P (SUBREG_REG (X)))))
  1693.  
  1694. #define RTX_OK_FOR_INDEX_P(X, STRICT)                    \
  1695.   ((GET_CODE (X) == REG                            \
  1696.     && (STRICT ? REG_OK_FOR_INDEX_P_STRICT (X) : REG_OK_FOR_INDEX_P (X)))\
  1697.    || (GET_CODE (X) == SUBREG                        \
  1698.        && GET_CODE (SUBREG_REG (X)) == REG                \
  1699.        && (STRICT ? REG_OK_FOR_INDEX_P_STRICT (SUBREG_REG (X))        \
  1700.        : REG_OK_FOR_INDEX_P (SUBREG_REG (X)))))
  1701.  
  1702. int
  1703. legitimate_address_p (mode, addr, strict)
  1704.      enum machine_mode mode;
  1705.      register rtx addr;
  1706.      int strict;
  1707. {
  1708.   if (RTX_OK_FOR_BASE_P (addr, strict))
  1709.     return 1;
  1710.   else if (CONSTANT_P (addr))
  1711.     return 1;
  1712.   else if (GET_CODE (addr) == PLUS)
  1713.     {
  1714.       rtx op0, op1;
  1715.  
  1716.       if (! TARGET_COMPLEX_ADDR && ! reload_completed)
  1717.     return 0;
  1718.  
  1719.       op0 = XEXP (addr, 0);
  1720.       op1 = XEXP (addr, 1);
  1721.  
  1722.       if (RTX_OK_FOR_BASE_P (op0, strict))
  1723.     {
  1724.       if (RTX_OK_FOR_INDEX_P (op1, strict))
  1725.         return 1;
  1726.       else if (CONSTANT_P (op1))
  1727.         return 1;
  1728.       else
  1729.         return 0;
  1730.     }
  1731.       else if (GET_CODE (op0) == PLUS)
  1732.     {
  1733.       if (GET_CODE (XEXP (op0, 0)) == MULT)
  1734.         {
  1735.           if (! (RTX_OK_FOR_INDEX_P (XEXP (XEXP (op0, 0), 0), strict)
  1736.              && SCALE_TERM_P (XEXP (XEXP (op0, 0), 1))))
  1737.         return 0;
  1738.  
  1739.           if (RTX_OK_FOR_BASE_P (XEXP (op0, 1), strict)
  1740.           && CONSTANT_P (op1))
  1741.         return 1;
  1742.           else
  1743.         return 0;
  1744.         }
  1745.       else if (RTX_OK_FOR_BASE_P (XEXP (op0, 0), strict))
  1746.         {
  1747.           if (RTX_OK_FOR_INDEX_P (XEXP (op0, 1), strict)
  1748.           && CONSTANT_P (op1))
  1749.         return 1;
  1750.           else
  1751.         return 0;
  1752.         }
  1753.       else
  1754.         return 0;
  1755.     }
  1756.       else if (GET_CODE (op0) == MULT)
  1757.     {
  1758.       if (! (RTX_OK_FOR_INDEX_P (XEXP (op0, 0), strict)
  1759.          && SCALE_TERM_P (XEXP (op0, 1))))
  1760.         return 0;
  1761.  
  1762.       if (RTX_OK_FOR_BASE_P (op1, strict))
  1763.         return 1;
  1764.       else if (CONSTANT_P (op1))
  1765.         return 1;
  1766.       else
  1767.         return 0;
  1768.     }
  1769.       else
  1770.     return 0;
  1771.     }
  1772.   else if (GET_CODE (addr) == MULT)
  1773.     {
  1774.       if (! TARGET_COMPLEX_ADDR && ! reload_completed)
  1775.     return 0;
  1776.  
  1777.       return (RTX_OK_FOR_INDEX_P (XEXP (addr, 0), strict)
  1778.           && SCALE_TERM_P (XEXP (addr, 1)));
  1779.     }
  1780.   else
  1781.     return 0;
  1782. }
  1783.  
  1784. /* Try machine-dependent ways of modifying an illegitimate address
  1785.    to be legitimate.  If we find one, return the new, valid address.
  1786.    This macro is used in only one place: `memory_address' in explow.c.
  1787.  
  1788.    This converts some non-canonical addresses to canonical form so they
  1789.    can be recognized.  */
  1790.  
  1791. rtx
  1792. legitimize_address (x, oldx, mode)
  1793.      register rtx x;
  1794.      register rtx oldx;
  1795.      enum machine_mode mode;
  1796. { 
  1797.   if (GET_CODE (x) == SYMBOL_REF)
  1798.     {
  1799.       abort ();
  1800.       x = copy_to_reg (x);
  1801.     }
  1802.  
  1803.   if (! TARGET_COMPLEX_ADDR && ! reload_completed)
  1804.     return x;
  1805.  
  1806.   /* Canonicalize (plus (mult (reg) (const)) (plus (reg) (const)))
  1807.      into (plus (plus (mult (reg) (const)) (reg)) (const)).  This can be
  1808.      created by virtual register instantiation, register elimination, and
  1809.      similar optimizations.  */
  1810.   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == MULT
  1811.       && GET_CODE (XEXP (x, 1)) == PLUS)
  1812.     x = gen_rtx (PLUS, Pmode,
  1813.          gen_rtx (PLUS, Pmode, XEXP (x, 0), XEXP (XEXP (x, 1), 0)),
  1814.          XEXP (XEXP (x, 1), 1));
  1815.  
  1816.   /* Canonicalize (plus (plus (mult (reg) (const)) (plus (reg) (const))) const)
  1817.      into (plus (plus (mult (reg) (const)) (reg)) (const)).  */
  1818.   else if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == PLUS
  1819.        && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
  1820.        && GET_CODE (XEXP (XEXP (x, 0), 1)) == PLUS
  1821.        && CONSTANT_P (XEXP (x, 1)))
  1822.     {
  1823.       rtx constant, other;
  1824.  
  1825.       if (GET_CODE (XEXP (x, 1)) == CONST_INT)
  1826.     {
  1827.       constant = XEXP (x, 1);
  1828.       other = XEXP (XEXP (XEXP (x, 0), 1), 1);
  1829.     }
  1830.       else if (GET_CODE (XEXP (XEXP (XEXP (x, 0), 1), 1)) == CONST_INT)
  1831.     {
  1832.       constant = XEXP (XEXP (XEXP (x, 0), 1), 1);
  1833.       other = XEXP (x, 1);
  1834.     }
  1835.       else
  1836.     constant = 0;
  1837.  
  1838.       if (constant)
  1839.     x = gen_rtx (PLUS, Pmode,
  1840.              gen_rtx (PLUS, Pmode, XEXP (XEXP (x, 0), 0),
  1841.                   XEXP (XEXP (XEXP (x, 0), 1), 0)),
  1842.              plus_constant (other, INTVAL (constant)));
  1843.     }
  1844.  
  1845.   return x;
  1846. }
  1847.  
  1848. #if 0
  1849. /* Return the most stringent alignment that we are willing to consider
  1850.    objects of size SIZE and known alignment ALIGN as having. */
  1851.    
  1852. int
  1853. i960_alignment (size, align)
  1854.      int size;
  1855.      int align;
  1856. {
  1857.   int i;
  1858.  
  1859.   if (! TARGET_STRICT_ALIGN)
  1860.     if (TARGET_IC_COMPAT2_0 || align >= 4)
  1861.       {
  1862.     i = i960_object_bytes_bitalign (size) / BITS_PER_UNIT;
  1863.     if (i > align)
  1864.       align = i;
  1865.       }
  1866.  
  1867.   return align;
  1868. }
  1869. #endif
  1870.  
  1871. /* Modes for condition codes.  */
  1872. #define C_MODES        \
  1873.   ((1 << (int) CCmode) | (1 << (int) CC_UNSmode) | (1<< (int) CC_CHKmode))
  1874.  
  1875. /* Modes for single-word (and smaller) quantities.  */
  1876. #define S_MODES                        \
  1877.  (~C_MODES                        \
  1878.   & ~ ((1 << (int) DImode) | (1 << (int) TImode)    \
  1879.        | (1 << (int) DFmode) | (1 << (int) XFmode)))
  1880.  
  1881. /* Modes for double-word (and smaller) quantities.  */
  1882. #define D_MODES                    \
  1883.   (~C_MODES                    \
  1884.    & ~ ((1 << (int) TImode) | (1 << (int) XFmode)))
  1885.  
  1886. /* Modes for quad-word quantities.  */
  1887. #define T_MODES (~C_MODES)
  1888.  
  1889. /* Modes for single-float quantities.  */
  1890. #define SF_MODES ((1 << (int) SFmode))
  1891.  
  1892. /* Modes for double-float quantities.  */
  1893. #define DF_MODES (SF_MODES | (1 << (int) DFmode) | (1 << (int) SCmode))
  1894.  
  1895. /* Modes for quad-float quantities.  */
  1896. #define XF_MODES (DF_MODES | (1 << (int) XFmode) | (1 << (int) DCmode))
  1897.  
  1898. unsigned int hard_regno_mode_ok[FIRST_PSEUDO_REGISTER] = {
  1899.   T_MODES, S_MODES, D_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES,
  1900.   T_MODES, S_MODES, D_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES,
  1901.   T_MODES, S_MODES, D_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES,
  1902.   T_MODES, S_MODES, D_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES,
  1903.  
  1904.   XF_MODES, XF_MODES, XF_MODES, XF_MODES, C_MODES};
  1905.  
  1906.  
  1907. /* Return the minimum alignment of an expression rtx X in bytes.  This takes
  1908.    advantage of machine specific facts, such as knowing that the frame pointer
  1909.    is always 16 byte aligned.  */
  1910.  
  1911. int
  1912. i960_expr_alignment (x, size)
  1913.      rtx x;
  1914.      int size;
  1915. {
  1916.   int align = 1;
  1917.  
  1918.   if (x == 0)
  1919.     return 1;
  1920.  
  1921.   switch (GET_CODE(x))
  1922.     {
  1923.     case CONST_INT:
  1924.       align = INTVAL(x);
  1925.  
  1926.       if ((align & 0xf) == 0)
  1927.     align = 16;
  1928.       else if ((align & 0x7) == 0)
  1929.     align = 8;
  1930.       else if ((align & 0x3) == 0)
  1931.     align = 4;
  1932.       else if ((align & 0x1) == 0)
  1933.     align = 2;
  1934.       else
  1935.     align = 1;
  1936.       break;
  1937.  
  1938.     case PLUS:
  1939.       align = MIN (i960_expr_alignment (XEXP (x, 0), size),
  1940.            i960_expr_alignment (XEXP (x, 1), size));
  1941.       break;
  1942.  
  1943.     case SYMBOL_REF:
  1944.       /* If this is a valid program, objects are guaranteed to be
  1945.      correctly aligned for whatever size the reference actually is. */
  1946.       align = i960_object_bytes_bitalign (size) / BITS_PER_UNIT;
  1947.       break;
  1948.  
  1949.     case REG:
  1950.       if (REGNO (x) == FRAME_POINTER_REGNUM)
  1951.     align = 16;
  1952.       break;
  1953.  
  1954.     case ASHIFT:
  1955.       align = i960_expr_alignment (XEXP (x, 0));
  1956.  
  1957.       if (GET_CODE (XEXP (x, 1)) == CONST_INT)
  1958.     {
  1959.       align = align << INTVAL (XEXP (x, 1));
  1960.       align = MIN (align, 16);
  1961.     }
  1962.       break;
  1963.  
  1964.     case MULT:
  1965.       align = (i960_expr_alignment (XEXP (x, 0), size) *
  1966.            i960_expr_alignment (XEXP (x, 1), size));
  1967.  
  1968.       align = MIN (align, 16);
  1969.       break;
  1970.     }
  1971.  
  1972.   return align;
  1973. }
  1974.  
  1975. /* Return true if it is possible to reference both BASE and OFFSET, which
  1976.    have alignment at least as great as 4 byte, as if they had alignment valid
  1977.    for an object of size SIZE.  */
  1978.  
  1979. int
  1980. i960_improve_align (base, offset, size)
  1981.      rtx base;
  1982.      rtx offset;
  1983.      int size;
  1984. {
  1985.   int i, j;
  1986.  
  1987.   /* We have at least a word reference to the object, so we know it has to
  1988.      be aligned at least to 4 bytes.  */
  1989.  
  1990.   i = MIN (i960_expr_alignment (base, 4),
  1991.        i960_expr_alignment (offset, 4));
  1992.  
  1993.   i = MAX (i, 4);
  1994.  
  1995.   /* We know the size of the request.  If strict align is not enabled, we
  1996.      can guess that the alignment is OK for the requested size.  */
  1997.  
  1998.   if (! TARGET_STRICT_ALIGN)
  1999.     if ((j = (i960_object_bytes_bitalign (size) / BITS_PER_UNIT)) > i)
  2000.       i = j;
  2001.  
  2002.   return (i >= size);
  2003. }
  2004.  
  2005. /* Return true if it is possible to access BASE and OFFSET, which have 4 byte
  2006.    (SImode) alignment as if they had 16 byte (TImode) alignment.  */
  2007.  
  2008. int
  2009. i960_si_ti (base, offset)
  2010.      rtx base;
  2011.      rtx offset;
  2012. {
  2013.   return i960_improve_align (base, offset, 16);
  2014. }
  2015.  
  2016. /* Return true if it is possible to access BASE and OFFSET, which have 4 byte
  2017.    (SImode) alignment as if they had 8 byte (DImode) alignment.  */
  2018.  
  2019. int
  2020. i960_si_di (base, offset)
  2021.      rtx base;
  2022.      rtx offset;
  2023. {
  2024.   return i960_improve_align (base, offset, 8);
  2025. }
  2026.  
  2027. /* Return raw values of size and alignment (in words) for the data
  2028.    type being accessed.  These values will be rounded by the caller.  */
  2029.  
  2030. static void 
  2031. i960_arg_size_and_align (mode, type, size_out, align_out)
  2032.      enum machine_mode mode;
  2033.      tree type;
  2034.      int *size_out;
  2035.      int *align_out;
  2036. {
  2037.   int size, align;
  2038.  
  2039.   /* Use formal alignment requirements of type being passed, except make
  2040.      it at least a word.  If we don't have a type, this is a library call,
  2041.      and the parm has to be of scalar type.  In this case, consider its
  2042.      formal alignment requirement to be its size in words.  */
  2043.  
  2044.   if (mode == BLKmode)
  2045.     size = (int_size_in_bytes (type) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
  2046.   else if (mode == VOIDmode)
  2047.     {
  2048.       /* End of parm list.  */
  2049.       assert (type != 0 && TYPE_MODE (type) == VOIDmode);
  2050.       size = 1;
  2051.     }
  2052.   else
  2053.     size = (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
  2054.  
  2055.   if (type == 0)
  2056.     align = size;
  2057.   else if (TYPE_ALIGN (type) >= BITS_PER_WORD)
  2058.     align = TYPE_ALIGN (type) / BITS_PER_WORD;
  2059.   else
  2060.     align = 1;
  2061.  
  2062.   *size_out  = size;
  2063.   *align_out = align;
  2064. }
  2065.  
  2066. /* On the 80960 the first 12 args are in registers and the rest are pushed.
  2067.    Any arg that is bigger than 4 words is placed on the stack and all
  2068.    subsequent arguments are placed on the stack.
  2069.  
  2070.    Additionally, parameters with an alignment requirement stronger than
  2071.    a word must be be aligned appropriately.  */
  2072.  
  2073. /* Update CUM to advance past an argument described by MODE and TYPE.  */
  2074.  
  2075. void
  2076. i960_function_arg_advance (cum, mode, type, named)
  2077.      CUMULATIVE_ARGS *cum;
  2078.      enum machine_mode mode;
  2079.      tree type;
  2080.      int named;
  2081. {
  2082.   int size, align;
  2083.  
  2084.   i960_arg_size_and_align (mode, type, &size, &align);
  2085.  
  2086.   if (size > 4 || cum->ca_nstackparms != 0
  2087.       || (size + ROUND_PARM (cum->ca_nregparms, align)) > NPARM_REGS
  2088.       || MUST_PASS_IN_STACK (mode, type))
  2089.     {
  2090.       /* Indicate that all the registers are in use, even if all are not,
  2091.      so va_start will compute the right value.  */
  2092.       cum->ca_nregparms = NPARM_REGS;
  2093.       cum->ca_nstackparms = ROUND_PARM (cum->ca_nstackparms, align) + size;
  2094.     }
  2095.   else
  2096.     cum->ca_nregparms = ROUND_PARM (cum->ca_nregparms, align) + size;
  2097. }
  2098.  
  2099. /* Return the register that the argument described by MODE and TYPE is
  2100.    passed in, or else return 0 if it is passed on the stack.  */
  2101.  
  2102. rtx
  2103. i960_function_arg (cum, mode, type, named)
  2104.      CUMULATIVE_ARGS *cum;
  2105.      enum machine_mode mode;
  2106.      tree type;
  2107.      int named;
  2108. {
  2109.   rtx ret;
  2110.   int size, align;
  2111.  
  2112.   i960_arg_size_and_align (mode, type, &size, &align);
  2113.  
  2114.   if (size > 4 || cum->ca_nstackparms != 0
  2115.       || (size + ROUND_PARM (cum->ca_nregparms, align)) > NPARM_REGS
  2116.       || MUST_PASS_IN_STACK (mode, type))
  2117.     {
  2118.       cum->ca_nstackparms = ROUND_PARM (cum->ca_nstackparms, align);
  2119.       ret = 0;
  2120.     }
  2121.   else
  2122.     {
  2123.       cum->ca_nregparms = ROUND_PARM (cum->ca_nregparms, align);
  2124.       ret = gen_rtx (REG, mode, cum->ca_nregparms);
  2125.     }
  2126.  
  2127.   return ret;
  2128. }
  2129.  
  2130. /* Floating-point support.  */
  2131.  
  2132. void
  2133. i960_output_long_double (file, value)
  2134.      FILE *file;
  2135.      REAL_VALUE_TYPE value;
  2136. {
  2137.   long value_long[3];
  2138.   char dstr[30];
  2139.  
  2140.   REAL_VALUE_TO_TARGET_LONG_DOUBLE (value, value_long);
  2141.   REAL_VALUE_TO_DECIMAL (value, "%.20g", dstr);
  2142.  
  2143.   fprintf (file,
  2144.        "\t.word\t0x%08lx\t\t# %s\n\t.word\t0x%08lx\n\t.word\t0x%08lx\n",
  2145.        value_long[0], dstr, value_long[1], value_long[2]);
  2146.   fprintf (file, "\t.word\t0x0\n");
  2147. }
  2148.  
  2149. void
  2150. i960_output_double (file, value)
  2151.      FILE *file;
  2152.      REAL_VALUE_TYPE value;
  2153. {
  2154.   long value_long[2];
  2155.   char dstr[30];
  2156.  
  2157.   REAL_VALUE_TO_TARGET_DOUBLE (value, value_long);
  2158.   REAL_VALUE_TO_DECIMAL (value, "%.20g", dstr);
  2159.  
  2160.   fprintf (file, "\t.word\t0x%08lx\t\t# %s\n\t.word\t0x%08lx\n",
  2161.        value_long[0], dstr, value_long[1]);
  2162. }
  2163.   
  2164. void
  2165. i960_output_float (file, value)
  2166.      FILE *file;
  2167.      REAL_VALUE_TYPE value;
  2168. {
  2169.   long value_long;
  2170.   char dstr[30];
  2171.  
  2172.   REAL_VALUE_TO_TARGET_SINGLE (value, value_long);
  2173.   REAL_VALUE_TO_DECIMAL (value, "%.12g", dstr);
  2174.  
  2175.   fprintf (file, "\t.word\t0x%08lx\t\t# %s (float)\n", value_long, dstr);
  2176. }
  2177.  
  2178. /* Return the number of bits that an object of size N bytes is aligned to.  */
  2179.  
  2180. int
  2181. i960_object_bytes_bitalign (n)
  2182.      int n;
  2183. {
  2184.   if (n > 8)      n = 128;
  2185.   else if (n > 4) n = 64;
  2186.   else if (n > 2) n = 32;
  2187.   else if (n > 1) n = 16;
  2188.   else            n = 8;
  2189.  
  2190.   return n;
  2191. }
  2192.  
  2193. /* Compute the alignment for an aggregate type TSIZE.
  2194.    Alignment is MAX (greatest member alignment,
  2195.                      MIN (pragma align, structure size alignment)).  */
  2196.  
  2197. int
  2198. i960_round_align (align, tsize)
  2199.      int align;
  2200.      tree tsize;
  2201. {
  2202.   int new_align;
  2203.  
  2204.   if (TREE_CODE (tsize) != INTEGER_CST)
  2205.     return align;
  2206.  
  2207.   new_align = i960_object_bytes_bitalign (TREE_INT_CST_LOW (tsize)
  2208.                       / BITS_PER_UNIT);
  2209.   /* Handle #pragma align.  */
  2210.   if (new_align > i960_maxbitalignment)
  2211.     new_align = i960_maxbitalignment;
  2212.  
  2213.   if (align < new_align)
  2214.     align = new_align;
  2215.  
  2216.   return align;
  2217. }
  2218.  
  2219. /* Do any needed setup for a varargs function.  For the i960, we must
  2220.    create a register parameter block if one doesn't exist, and then copy
  2221.    all register parameters to memory.  */
  2222.  
  2223. void
  2224. i960_setup_incoming_varargs (cum, mode, type, pretend_size, no_rtl)
  2225.      CUMULATIVE_ARGS *cum;
  2226.      enum machine_mode mode;
  2227.      tree type;
  2228.      int *pretend_size;
  2229.      int no_rtl;
  2230. {
  2231.   /* Note: for a varargs fn with only a va_alist argument, this is 0.  */
  2232.   int first_reg = cum->ca_nregparms;
  2233.  
  2234.   /* Copy only unnamed register arguments to memory.  If there are
  2235.      any stack parms, there are no unnamed arguments in registers, and
  2236.      an argument block was already allocated by the caller.
  2237.      Remember that any arg bigger than 4 words is passed on the stack as
  2238.      are all subsequent args.
  2239.  
  2240.      If there are no stack arguments but there are exactly NPARM_REGS
  2241.      registers, either there were no extra arguments or the caller
  2242.      allocated an argument block. */
  2243.  
  2244.   if (cum->ca_nstackparms == 0 && first_reg < NPARM_REGS && !no_rtl)
  2245.     {
  2246.       rtx label = gen_label_rtx ();
  2247.       rtx regblock;
  2248.  
  2249.       /* If arg_pointer_rtx == 0, no arguments were passed on the stack
  2250.      and we need to allocate a chunk to save the registers (if any
  2251.      arguments were passed on the stack the caller would allocate the
  2252.      48 bytes as well).  We must allocate all 48 bytes (12*4) because
  2253.      va_start assumes it.  */
  2254.       emit_insn (gen_cmpsi (arg_pointer_rtx, const0_rtx));
  2255.       emit_jump_insn (gen_bne (label));
  2256.       emit_insn (gen_rtx (SET, VOIDmode, arg_pointer_rtx,
  2257.               stack_pointer_rtx));
  2258.       emit_insn (gen_rtx (SET, VOIDmode, stack_pointer_rtx,
  2259.               memory_address (SImode,
  2260.                       plus_constant (stack_pointer_rtx,
  2261.                              48))));
  2262.       emit_label (label);
  2263.  
  2264.       /* ??? Note that we unnecessarily store one extra register for stdarg
  2265.      fns.  We could optimize this, but it's kept as for now.  */
  2266.       regblock = gen_rtx (MEM, BLKmode,
  2267.               plus_constant (arg_pointer_rtx,
  2268.                      first_reg * 4));
  2269.       move_block_from_reg (first_reg, regblock,
  2270.                NPARM_REGS - first_reg,
  2271.                (NPARM_REGS - first_reg) * UNITS_PER_WORD);
  2272.     }
  2273. }
  2274.  
  2275. /* Calculate the final size of the reg parm stack space for the current
  2276.    function, based on how many bytes would be allocated on the stack.  */
  2277.  
  2278. int
  2279. i960_final_reg_parm_stack_space (const_size, var_size)
  2280.      int const_size;
  2281.      tree var_size;
  2282. {
  2283.   if (var_size || const_size > 48)
  2284.     return 48;
  2285.   else
  2286.     return 0;
  2287. }
  2288.  
  2289. /* Calculate the size of the reg parm stack space.  This is a bit complicated
  2290.    on the i960.  */
  2291.  
  2292. int
  2293. i960_reg_parm_stack_space (fndecl)
  2294.      tree fndecl;
  2295. {
  2296.   /* In this case, we are called from emit_library_call, and we don't need
  2297.      to pretend we have more space for parameters than what's apparent.  */
  2298.   if (fndecl == 0)
  2299.     return 0;
  2300.  
  2301.   /* In this case, we are called from locate_and_pad_parms when we're
  2302.      not IN_REGS, so we have an arg block.  */
  2303.   if (fndecl != current_function_decl)
  2304.     return 48;
  2305.  
  2306.   /* Otherwise, we have an arg block if the current function has more than
  2307.      48 bytes of parameters.  */
  2308.   if (current_function_args_size != 0 || VARARGS_STDARG_FUNCTION (fndecl))
  2309.     return 48;
  2310.   else
  2311.     return 0;
  2312. }
  2313.  
  2314. /* Return the register class of a scratch register needed to copy IN into
  2315.    or out of a register in CLASS in MODE.  If it can be done directly,
  2316.    NO_REGS is returned.  */
  2317.  
  2318. enum reg_class
  2319. secondary_reload_class (class, mode, in)
  2320.      enum reg_class class;
  2321.      enum machine_mode mode;
  2322.      rtx in;
  2323. {
  2324.   int regno = -1;
  2325.  
  2326.   if (GET_CODE (in) == REG || GET_CODE (in) == SUBREG)
  2327.     regno = true_regnum (in);
  2328.  
  2329.   /* We can place anything into LOCAL_OR_GLOBAL_REGS and can put
  2330.      LOCAL_OR_GLOBAL_REGS into anything.  */
  2331.   if (class == LOCAL_OR_GLOBAL_REGS || class == LOCAL_REGS
  2332.       || class == GLOBAL_REGS || (regno >= 0 && regno < 32))
  2333.     return NO_REGS;
  2334.  
  2335.   /* We can place any hard register, 0.0, and 1.0 into FP_REGS.  */
  2336.   if (class == FP_REGS
  2337.       && ((regno >= 0 && regno < FIRST_PSEUDO_REGISTER)
  2338.       || in == CONST0_RTX (mode) || in == CONST1_RTX (mode)))
  2339.     return NO_REGS;
  2340.  
  2341.   return LOCAL_OR_GLOBAL_REGS;
  2342. }
  2343.  
  2344. /* Look at the opcode P, and set i96_last_insn_type to indicate which
  2345.    function unit it executed on.  */
  2346.  
  2347. /* ??? This would make more sense as an attribute.  */
  2348.  
  2349. void
  2350. i960_scan_opcode (p)
  2351.      char *p;
  2352. {
  2353.   switch (*p)
  2354.     {
  2355.     case 'a':
  2356.     case 'd':
  2357.     case 'e':
  2358.     case 'm':
  2359.     case 'n':
  2360.     case 'o':
  2361.     case 'r':
  2362.       /* Ret is not actually of type REG, but it won't matter, because no
  2363.      insn will ever follow it.  */
  2364.     case 'u':
  2365.     case 'x':
  2366.       i960_last_insn_type = I_TYPE_REG;
  2367.       break;
  2368.  
  2369.     case 'b':
  2370.       if (p[1] == 'x' || p[3] == 'x')
  2371.         i960_last_insn_type = I_TYPE_MEM;
  2372.       i960_last_insn_type = I_TYPE_CTRL;
  2373.       break;
  2374.  
  2375.     case 'f':
  2376.     case 't':
  2377.       i960_last_insn_type = I_TYPE_CTRL;
  2378.       break;
  2379.  
  2380.     case 'c':
  2381.       if (p[1] == 'a')
  2382.     {
  2383.       if (p[4] == 'x')
  2384.         i960_last_insn_type = I_TYPE_MEM;
  2385.       else
  2386.         i960_last_insn_type = I_TYPE_CTRL;
  2387.     }
  2388.       else if (p[1] == 'm')
  2389.     {
  2390.       if (p[3] == 'd')
  2391.         i960_last_insn_type = I_TYPE_REG;
  2392.       else if (p[4] == 'b' || p[4] == 'j')
  2393.         i960_last_insn_type = I_TYPE_CTRL;
  2394.       else
  2395.         i960_last_insn_type = I_TYPE_REG;
  2396.     }
  2397.       else
  2398.         i960_last_insn_type = I_TYPE_REG;
  2399.       break;
  2400.  
  2401.     case 'l':
  2402.       i960_last_insn_type = I_TYPE_MEM;
  2403.       break;
  2404.  
  2405.     case 's':
  2406.       if (p[1] == 't')
  2407.         i960_last_insn_type = I_TYPE_MEM;
  2408.       else
  2409.         i960_last_insn_type = I_TYPE_REG;
  2410.       break;
  2411.     }
  2412. }
  2413.